import express, { Request, Response, Router } from 'express';
import * as bcrypt from 'bcrypt';
import { PrismaClient } from '@prisma/client';
import { ApiResponse } from '../../utils/response';
import { adminAuthMiddleware, requireSuperAdmin } from '../../middleware/adminAuth';

const router: Router = express.Router();
const prisma = new PrismaClient();

// 生成唯一的合作伙伴邀请码
const generatePartnerCode = async (): Promise<string> => {
  let code: string;
  let exists = true;

  while (exists) {
    // 生成8位随机码（大写字母+数字）
    code = Math.random().toString(36).substring(2, 10).toUpperCase();

    // 检查是否已存在
    const existingAdmin = await prisma.admin.findUnique({
      where: { partnerCode: code }
    });

    exists = !!existingAdmin;
  }

  return code!;
};

// 创建合作伙伴（仅超级管理员）
router.post('/', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { username, password, name, partnerCode } = req.body;

    if (!username || !password || !name) {
      res.status(400).json(ApiResponse.error('아이디, 비밀번호, 이름은 모두 필수 입력입니다.'));
      return;
    }

    if (password.length < 6) {
      res.status(400).json(ApiResponse.error('비밀번호는 최소 6자 이상이어야 합니다.'));
      return;
    }

    // 检查用户名是否已存在
    const existingAdmin = await prisma.admin.findUnique({
      where: { username }
    });

    if (existingAdmin) {
      res.status(400).json(ApiResponse.error('이미 사용 중인 아이디입니다.'));
      return;
    }

    // 生成或验证合作伙伴邀请码
    let finalPartnerCode = partnerCode;

    if (partnerCode) {
      // 如果提供了邀请码，检查是否已存在
      const existingCode = await prisma.admin.findUnique({
        where: { partnerCode }
      });

      if (existingCode) {
        res.status(400).json(ApiResponse.error('이 초대 코드는 이미 사용 중입니다.'));
        return;
      }
    } else {
      // 如果没有提供，自动生成
      finalPartnerCode = await generatePartnerCode();
    }

    // 加密密码
    const hashedPassword = await bcrypt.hash(password, 12);

    // 创建合作伙伴
    const newPartner = await prisma.admin.create({
      data: {
        username,
        password: hashedPassword,
        name,
        role: 'PARTNER',
        status: 'ACTIVE',
        isPartner: true,
        partnerCode: finalPartnerCode
      },
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        isPartner: true,
        partnerCode: true,
        createdAt: true
      }
    });

    res.status(201).json(ApiResponse.success(newPartner, '파트너가 성공적으로 생성되었습니다.'));

  } catch (error) {
    console.error('파트너 생성 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 생성에 실패했습니다.'));
  }
});

// 获取合作伙伴列表（仅超级管理员）
router.get('/', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { page = 1, limit = 20, status, keyword } = req.query;

    const where: any = {
      isPartner: true,
      role: 'PARTNER'
    };

    if (status) {
      where.status = status;
    }

    if (keyword) {
      where.OR = [
        { username: { contains: keyword as string } },
        { name: { contains: keyword as string } },
        { partnerCode: { contains: keyword as string } }
      ];
    }

    const partners = await prisma.admin.findMany({
      where,
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        isPartner: true,
        partnerCode: true,
        createdAt: true,
        updatedAt: true,
        _count: {
          select: {
            partnerUsers: true  // 统计关联的用户数量
          }
        }
      },
      orderBy: { createdAt: 'desc' },
      skip: (Number(page) - 1) * Number(limit),
      take: Number(limit)
    });

    const total = await prisma.admin.count({ where });

    // 格式化数据，添加用户数量
    const formattedPartners = partners.map(partner => ({
      ...partner,
      userCount: partner._count.partnerUsers,
      _count: undefined
    }));

    res.json(ApiResponse.success({
      partners: formattedPartners,
      pagination: {
        page: Number(page),
        limit: Number(limit),
        total: Number(total),
        totalPages: Math.ceil(Number(total) / Number(limit))
      }
    }));

  } catch (error) {
    console.error('파트너 목록 조회 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 목록 조회에 실패했습니다.'));
  }
});

// 获取可添加的用户列表（未绑定合作伙伴的用户）
// 注意：这个路由必须在 GET /:id 之前，否则 "available-users" 会被当作 id 参数
router.get('/available-users', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { page = 1, limit = 20, search } = req.query;

    const where: any = {
      partnerAdminId: null  // 只查询未绑定合作伙伴的用户
    };

    if (search) {
      where.OR = [
        { name: { contains: search as string } },
        { idNumber: { contains: search as string } },
        { mobileNumber: { contains: search as string } }
      ];
    }

    const users = await prisma.user.findMany({
      where,
      select: {
        id: true,
        idNumber: true,
        name: true,
        mobileNumber: true,
        status: true,
        createdAt: true
      },
      orderBy: { createdAt: 'desc' },
      skip: (Number(page) - 1) * Number(limit),
      take: Number(limit)
    });

    const total = await prisma.user.count({ where });

    res.json(ApiResponse.success({
      users,
      pagination: {
        page: Number(page),
        limit: Number(limit),
        total: Number(total),
        totalPages: Math.ceil(Number(total) / Number(limit))
      }
    }));

  } catch (error) {
    console.error('사용 가능한 회원 목록 조회 오류:', error);
    res.status(500).json(ApiResponse.error('사용 가능한 회원 목록 조회에 실패했습니다.'));
  }
});

// 获取合作伙伴详情（仅超级管理员）
router.get('/:id', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;

    const partner = await prisma.admin.findFirst({
      where: {
        id: parseInt(id),
        isPartner: true
      },
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        isPartner: true,
        partnerCode: true,
        createdAt: true,
        updatedAt: true,
        _count: {
          select: {
            partnerUsers: true
          }
        }
      }
    });

    if (!partner) {
      res.status(404).json(ApiResponse.error('파트너를 찾을 수 없습니다.'));
      return;
    }

    const formattedPartner = {
      ...partner,
      userCount: partner._count.partnerUsers,
      _count: undefined
    };

    res.json(ApiResponse.success(formattedPartner));

  } catch (error) {
    console.error('파트너 상세 조회 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 상세 조회에 실패했습니다.'));
  }
});

// 更新合作伙伴信息（仅超级管理员）
router.put('/:id', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { name, password, partnerCode } = req.body;

    const partner = await prisma.admin.findFirst({
      where: {
        id: parseInt(id),
        isPartner: true
      }
    });

    if (!partner) {
      res.status(404).json(ApiResponse.error('파트너를 찾을 수 없습니다.'));
      return;
    }

    const updateData: any = {};

    if (name) {
      updateData.name = name;
    }

    if (password) {
      if (password.length < 6) {
        res.status(400).json(ApiResponse.error('비밀번호는 최소 6자 이상이어야 합니다.'));
        return;
      }
      updateData.password = await bcrypt.hash(password, 12);
    }

    if (partnerCode && partnerCode !== partner.partnerCode) {
      // 检查新的邀请码是否已被使用
      const existingCode = await prisma.admin.findUnique({
        where: { partnerCode }
      });

      if (existingCode) {
        res.status(400).json(ApiResponse.error('이 초대 코드는 이미 사용 중입니다.'));
        return;
      }

      updateData.partnerCode = partnerCode;
    }

    const updatedPartner = await prisma.admin.update({
      where: { id: parseInt(id) },
      data: updateData,
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        isPartner: true,
        partnerCode: true,
        updatedAt: true
      }
    });

    res.json(ApiResponse.success(updatedPartner, '파트너 정보가 성공적으로 업데이트되었습니다.'));

  } catch (error) {
    console.error('파트너 정보 업데이트 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 정보 업데이트에 실패했습니다.'));
  }
});

// 更新合作伙伴状态（仅超级管理员）
router.post('/:id/status', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { status } = req.body;

    const validStatuses = ['ACTIVE', 'INACTIVE', 'SUSPENDED'];
    if (!validStatuses.includes(status)) {
      res.status(400).json(ApiResponse.error('유효하지 않은 상태입니다.'));
      return;
    }

    const partner = await prisma.admin.findFirst({
      where: {
        id: parseInt(id),
        isPartner: true
      }
    });

    if (!partner) {
      res.status(404).json(ApiResponse.error('파트너를 찾을 수 없습니다.'));
      return;
    }

    const updatedPartner = await prisma.admin.update({
      where: { id: parseInt(id) },
      data: { status },
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        partnerCode: true
      }
    });

    res.json(ApiResponse.success(updatedPartner, '파트너 상태가 성공적으로 업데이트되었습니다.'));

  } catch (error) {
    console.error('파트너 상태 업데이트 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 상태 업데이트에 실패했습니다.'));
  }
});

// 删除合作伙伴（仅超级管理员）
router.delete('/:id', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;

    const partner = await prisma.admin.findFirst({
      where: {
        id: parseInt(id),
        isPartner: true
      },
      include: {
        _count: {
          select: {
            partnerUsers: true
          }
        }
      }
    });

    if (!partner) {
      res.status(404).json(ApiResponse.error('파트너를 찾을 수 없습니다.'));
      return;
    }

    // 检查是否有关联用户
    if (partner._count.partnerUsers > 0) {
      res.status(400).json(ApiResponse.error('이 파트너에 연결된 회원이 있어 삭제할 수 없습니다. 먼저 회원을 다른 파트너로 이전하거나 삭제해 주세요.'));
      return;
    }

    await prisma.admin.delete({
      where: { id: parseInt(id) }
    });

    res.json(ApiResponse.success(null, '파트너가 성공적으로 삭제되었습니다.'));

  } catch (error) {
    console.error('파트너 삭제 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 삭제에 실패했습니다.'));
  }
});

// 获取合作伙伴的用户列表（仅超级管理员）
router.get('/:id/users', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { page = 1, limit = 20 } = req.query;

    const partner = await prisma.admin.findFirst({
      where: {
        id: parseInt(id),
        isPartner: true
      }
    });

    if (!partner) {
      res.status(404).json(ApiResponse.error('파트너를 찾을 수 없습니다.'));
      return;
    }

    const users = await prisma.user.findMany({
      where: {
        partnerAdminId: parseInt(id)
      },
      select: {
        id: true,
        idNumber: true,
        name: true,
        username: true,
        status: true,
        createdAt: true
      },
      orderBy: { createdAt: 'desc' },
      skip: (Number(page) - 1) * Number(limit),
      take: Number(limit)
    });

    const total = await prisma.user.count({
      where: {
        partnerAdminId: parseInt(id)
      }
    });

    res.json(ApiResponse.success({
      users,
      pagination: {
        page: Number(page),
        limit: Number(limit),
        total: Number(total),
        totalPages: Math.ceil(Number(total) / Number(limit))
      }
    }));

  } catch (error) {
    console.error('파트너 회원 목록 조회 오류:', error);
    res.status(500).json(ApiResponse.error('파트너 회원 목록 조회에 실패했습니다.'));
  }
});

// 将用户添加到合作伙伴
router.post('/:id/users', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { userIds } = req.body;

    if (!userIds || !Array.isArray(userIds) || userIds.length === 0) {
      res.status(400).json(ApiResponse.error('추가할 회원을 선택해 주세요.'));
      return;
    }

    // 验证合作伙伴是否存在
    const partner = await prisma.admin.findFirst({
      where: {
        id: parseInt(id),
        isPartner: true
      }
    });

    if (!partner) {
      res.status(404).json(ApiResponse.error('파트너를 찾을 수 없습니다.'));
      return;
    }

    // 验证用户是否存在且未绑定合作伙伴
    const usersToAdd = await prisma.user.findMany({
      where: {
        id: { in: userIds.map((id: any) => Number(id)) },
        partnerAdminId: null
      },
      select: {
        id: true,
        name: true
      }
    });

    if (usersToAdd.length === 0) {
      res.status(400).json(ApiResponse.error('추가할 수 있는 회원이 없습니다. 이미 다른 파트너에 속해 있을 수 있습니다.'));
      return;
    }

    // 批量更新用户的合作伙伴ID
    await prisma.user.updateMany({
      where: {
        id: { in: usersToAdd.map(u => u.id) }
      },
      data: {
        partnerAdminId: parseInt(id)
      }
    });

    res.json(ApiResponse.success({
      addedCount: usersToAdd.length,
      userIds: usersToAdd.map(u => u.id),
      users: usersToAdd
    }, `${usersToAdd.length}명의 회원이 성공적으로 추가되었습니다.`));

  } catch (error) {
    console.error('회원 추가 오류:', error);
    res.status(500).json(ApiResponse.error('회원 추가에 실패했습니다.'));
  }
});

export default router;
